home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1997 July / macformat52.iso / mac / Shareware Plus / Educational / LEE 2.1 / Source / macdisplay.c < prev    next >
Text File  |  1996-08-08  |  11KB  |  432 lines

  1. /* macdisplay.c    
  2.  *                         Copyright (1993)
  3.  *
  4.  *          Rik Belew.  University of California, San Diego
  5.  *        Greg Linden.  University of California, San Diego
  6.  *
  7.  *        This software may be redistributed without charge;
  8.  *                 this notice should be preserved.
  9.  */
  10.  
  11.  
  12.  
  13.  
  14.  
  15. #include "defs.h"
  16.  
  17.  
  18. #define        NEURAL_BOX_OFFSET    10
  19. #define        NEURAL_BOX_TOP        0.2
  20. #define        NEURAL_BOX_LEFT        0.4
  21. #define        NEURAL_BOX_BOTTOM    0.7
  22. #define        NEURAL_BOX_RIGHT    0.9
  23. #define        NEURAL_NODE_SIZE    5
  24. #define        BIAS_COLOR            1.0
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32. void ToolBoxInit() 
  33. {
  34.     InitGraf(&qd.thePort);
  35.     InitFonts();
  36.     FlushEvents(everyEvent, 0);
  37.     InitWindows();
  38.     InitMenus();
  39.     TEInit();
  40.     InitDialogs(NIL_POINTER);
  41.     InitCursor();
  42. }
  43.  
  44.  
  45.  
  46.  
  47.  
  48. /*    Initialize and set up the window used for display.  */
  49.  
  50.  
  51.  
  52. void InitWindow() {    
  53.     Rect    r;
  54.         
  55.     gZoomCellWindow = GetNewWindow(ZOOM_CELL_WIND, NIL_POINTER, NIL_POINTER); 
  56.     SetWTitle(gZoomCellWindow,"\pZooming...");
  57.     gCurrentZoomCell.v = -1;
  58.     gCurrentZoomCell.h = -1;
  59.     gCurrentZoomItem = -1;
  60.     gTheWindow = GetNewWindow(WINDOW_ID, NIL_POINTER, (WindowPtr)-1);
  61.     SetWTitle(gTheWindow, "\pLEE");
  62.     ShowWindow(gTheWindow);
  63.     SetPort(gTheWindow);
  64.     
  65.     TextSize(14);
  66.     
  67.     SetRect(&r, START_X - BORDER_OFFSET, START_Y - BORDER_OFFSET, START_X + BORDER_OFFSET + x_dim * SQUARE_SIZE, START_Y + BORDER_OFFSET + y_dim * SQUARE_SIZE);
  68.     FrameRect(&r);
  69. }
  70.  
  71.  
  72.  
  73.  
  74. /*    Load menu resources and set up menu bar.  */
  75.  
  76. void InitMenuBar () {
  77.     Handle        menuBar;
  78.  
  79.  
  80.     menuBar = GetNewMBar(MENU_BAR_ID);
  81.     SetMenuBar(menuBar);
  82.  
  83.     gAppleMenu = GetMHandle(APPLE_MENU_ID);
  84.     gFileMenu = GetMHandle(FILE_MENU_ID);
  85.     gEditMenu = GetMHandle(EDIT_MENU_ID);
  86.     gOptionsMenu = GetMHandle(OPTIONS_MENU_ID);
  87.  
  88.     AddResMenu(gAppleMenu, 'DRVR');
  89.  
  90.     DrawMenuBar();
  91. }
  92.  
  93.  
  94.  
  95.  
  96. /*    Draw world as grid of cells.  Used for initialization and to
  97.     redraw screen for updates.   */
  98.  
  99. int    initDrawWorld () 
  100. {
  101.     int        x,y;
  102.     Rect    r;
  103.     
  104.     SetRect(&r, START_X - BORDER_OFFSET, START_Y - BORDER_OFFSET, START_X + BORDER_OFFSET + x_dim * SQUARE_SIZE, START_Y + BORDER_OFFSET + y_dim * SQUARE_SIZE);
  105.     FrameRect(&r);
  106.     
  107.     for (y=0; y<y_dim; y++) 
  108.         for (x=0; x<x_dim; x++) 
  109.             drawCell(x,y);
  110. }
  111.  
  112.  
  113.  
  114.  
  115.  
  116. void DrawNode (x,y,bias) 
  117. int    x,y;
  118. float bias;
  119. {
  120.     Rect    r;
  121.     int        left, top, right, bottom;
  122.         
  123.     left = x - NEURAL_NODE_SIZE;
  124.     top = y - NEURAL_NODE_SIZE;
  125.     right = x + NEURAL_NODE_SIZE;
  126.     bottom = y + NEURAL_NODE_SIZE;
  127.     SetRect(&r, left, top, right, bottom);
  128.     
  129.     if (bias>BIAS_COLOR*2) 
  130.         FillOval(&r, &qd.black /* CW: qd.black */ );
  131.     else if (bias>BIAS_COLOR) {
  132.         FillOval(&r, &qd.dkGray /* CW: qd.dkGray */ );
  133.         FrameOval(&r);
  134.     }
  135.     else if (bias>-BIAS_COLOR) {
  136.         FillOval(&r, &qd.ltGray /* CW: qd.ltGray */ );
  137.         FrameOval(&r);
  138.     }
  139.     else if (bias>-BIAS_COLOR*2) {
  140.         FillOval(&r, &qd.white /* CW: qd.white */ );
  141.         FrameOval(&r);
  142.     }
  143.     else {
  144.         FillOval(&r, &qd.gray /* CW: qd.gray */ );
  145.         FrameOval(&r);
  146.     }
  147. }
  148.  
  149.  
  150.  
  151.     
  152.  
  153. void SelectCell (x,y, item)
  154. int    x,y, item;
  155. {
  156.     char        tempString[255];
  157.     GrafPtr        oldPort;
  158.     cell         *theCell;
  159.     Rect        r;
  160.     int            counter, foodType, top, bottom, left, right, level;
  161.     int            upperNode, lowerNode, startX, startY, endX, endY;
  162.     Handle        theIcon;
  163.     PenState    thePen;
  164.     float        NNetLevel, NNetLevelSize, theWeight, *weights;
  165.         
  166.     theCell = world[x][y];    
  167.     counter = item;
  168.     while (counter>0) {
  169.         theCell = theCell->next;
  170.         counter--;
  171.     }
  172.     
  173.     GetPort(&oldPort);
  174.     
  175.     SetPort(gZoomCellWindow);
  176.     
  177.     sprintf(tempString, "Cell %d x %d", x, y);
  178.     SetWTitle(gZoomCellWindow, CtoPstr(tempString));
  179.     FillRect(&(gZoomCellWindow->portRect), &qd.white /* CW: qd.white */ );
  180.     SelectWindow(gZoomCellWindow);
  181.     ShowWindow(gZoomCellWindow);
  182.     
  183.     if (theCell == NIL_POINTER) {
  184.         TextSize(24);
  185.         MoveTo(10,50);
  186.         DrawString("\pEMPTY.");
  187.     }
  188.     else {
  189.         if (theCell->type == food) {
  190.             SetRect(&r,10,10,50,50);
  191.             switch (theCell->datum.atom) {
  192.                 case 0:
  193.                     FillRect(&r,&qd.ltGray /* CW: qd.ltGray */ );
  194.                     break;
  195.                 case 1:
  196.                     FillRect(&r,&qd.dkGray /* CW: qd.dkGray */ );
  197.                     break;
  198.                 default:
  199.                     FillRect(&r,&qd.gray /* CW: qd.gray */ );
  200.                     break;
  201.             }
  202.             TextSize(9);
  203.             MoveTo(10,80);
  204.             sprintf(tempString, "Item #%d", item);
  205.             DrawString(CtoPstr(tempString));
  206.             MoveTo(10,90);
  207.             foodType = theCell->datum.atom;
  208.             sprintf(tempString, "Food Type:  %d", foodType);
  209.             DrawString(CtoPstr(tempString));
  210.         }
  211.         else {
  212.             SetRect(&r,10,10,50,50);
  213.             switch (theCell->datum.ap->direction) {
  214.                 case UP:
  215.                     FillArc(&r, 180+ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  216.                     break;
  217.                 case LEFT:
  218.                     FillArc(&r, 270+ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  219.                     break;
  220.                 case RIGHT:
  221.                     FillArc(&r, 90+ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  222.                     break;
  223.                 case DOWN:
  224.                     FillArc(&r, ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  225.                     break;
  226.             }
  227.             TextSize(9);
  228.             MoveTo(10,80);
  229.             sprintf(tempString, "Item #%d", item);
  230.             DrawString(CtoPstr(tempString));
  231.             MoveTo(10,90);
  232.             sprintf(tempString, "Energy:  %d", (int) theCell->datum.ap->energy);
  233.             DrawString(CtoPstr(tempString));
  234.  
  235.             top = (gZoomCellWindow->portRect.bottom - gZoomCellWindow->portRect.top) * NEURAL_BOX_TOP;
  236.             bottom = (gZoomCellWindow->portRect.bottom - gZoomCellWindow->portRect.top) * NEURAL_BOX_BOTTOM;
  237.             left = (gZoomCellWindow->portRect.right - gZoomCellWindow->portRect.left) * NEURAL_BOX_LEFT;
  238.             right = (gZoomCellWindow->portRect.right - gZoomCellWindow->portRect.left) * NEURAL_BOX_RIGHT;
  239.             SetRect(&r, left - NEURAL_BOX_OFFSET, top - NEURAL_BOX_OFFSET, right + NEURAL_BOX_OFFSET, bottom + NEURAL_BOX_OFFSET);
  240.             FrameRect(&r);
  241.             
  242.             GetPenState(&thePen);
  243.             
  244.             for (level = 0; level < nlayers-1; level++) 
  245.             {
  246.                 counter = 0;   /* BUG FIX: moved here from outside of enclosing for loop */
  247.                 weights = *(theCell->datum.ap->weightp + level);
  248.                 for (upperNode=0; upperNode < *(layer_descp+1+level); upperNode++)
  249.                 {
  250.                     for (lowerNode=0; lowerNode < *(layer_descp+level); lowerNode++) 
  251.                     {
  252.                         theWeight = *(weights + counter);
  253.                         startX = left+(right-left)*upperNode/(*(layer_descp+level+1)-1);
  254.                         endX = left+(right-left)*lowerNode/(*(layer_descp+level)-1);
  255.                         startY = top+(bottom-top)*(nlayers-level-2)/(nlayers-1);
  256.                         endY = top+(bottom-top)*(nlayers-level-1)/(nlayers-1);
  257.                         if (theWeight>weight_limit*2/3) {
  258.                             PenSize(2,2);
  259.                             PenPat(&qd.black);  /* CW: qd.black */ 
  260.                             MoveTo(startX, startY);
  261.                             LineTo(endX,endY);
  262.                         }
  263.                         if (theWeight<-weight_limit/3) {
  264.                             PenSize(1,1);
  265.                             PenPat(&qd.black);  /* CW: qd.black */ 
  266.                             MoveTo(startX, startY);
  267.                             LineTo(endX,endY);
  268.                         }
  269.                         if (theWeight>weight_limit/3) {
  270.                             PenSize(1,1);
  271.                             PenPat(&qd.gray);  /* CW: qd.gray */ 
  272.                             MoveTo(startX, startY);
  273.                             LineTo(endX,endY);
  274.                         }
  275.                         if (theWeight<-weight_limit*2/3) {
  276.                             PenSize(2,2);
  277.                             PenPat(&qd.gray);  /* CW: qd.gray */ 
  278.                             MoveTo(startX, startY);
  279.                             LineTo(endX,endY);
  280.                         }
  281.                         counter++;
  282.                     }
  283.                 }
  284.             }
  285.             SetPenState(&thePen);
  286.             
  287.             for (level = 0; level<nlayers; level++)
  288.                 for (counter = 0; counter<*(layer_descp+level); counter++) 
  289.                     DrawNode(left+(right-left)*counter/(*(layer_descp+level) - 1), top+(bottom-top)*(nlayers-level-1)/(nlayers-1), *(*(theCell->datum.ap->biasp + level)+counter));
  290.             SetPenState(&thePen);
  291.                 
  292.         }
  293.         
  294.         top = gZoomCellWindow->portRect.bottom - gZoomCellWindow->portRect.top - ARROW_OFFSET_BOTTOM;
  295.         left = (gZoomCellWindow->portRect.right - gZoomCellWindow->portRect.left) / 2 - ARROW_SIZE - ARROW_OFFSET_MIDDLE;
  296.         bottom = top + ARROW_SIZE;
  297.         right = left + ARROW_SIZE;
  298.         SetRect(&r, left , top, right, bottom);
  299.         theIcon = GetIcon(PREV_ICON);
  300.         if (theIcon == NIL_POINTER)
  301.             exit(1);
  302.         PlotIcon(&r, theIcon);
  303.         if (item==0) {
  304.             GetPenState(&thePen);
  305.             PenMode(patBic);
  306.             PenPat(&qd.ltGray /* CW: qd.ltGray */ );
  307.             PaintRect(&r);
  308.             SetPenState(&thePen);
  309.         }
  310.             
  311.         
  312.         top = gZoomCellWindow->portRect.bottom - gZoomCellWindow->portRect.top - ARROW_OFFSET_BOTTOM;
  313.         left = (gZoomCellWindow->portRect.right - gZoomCellWindow->portRect.left) / 2 + ARROW_OFFSET_MIDDLE;
  314.         bottom = top + ARROW_SIZE;
  315.         right = left + ARROW_SIZE;
  316.         SetRect(&r, left , top, right, bottom);
  317.         theIcon = GetIcon(NEXT_ICON);
  318.         if (theIcon == NIL_POINTER)
  319.             exit(1);
  320.         PlotIcon(&r, theIcon);
  321.         if (theCell->next==NIL_POINTER) {
  322.             GetPenState(&thePen);
  323.             PenMode(patBic);
  324.             PenPat(&qd.ltGray /* CW: qd.ltGray */ );
  325.             PaintRect(&r);
  326.             SetPenState(&thePen);
  327.         }
  328.     }
  329.     
  330.         
  331.     SetPort(oldPort);
  332. }
  333.  
  334.  
  335.  
  336.  
  337. /*    Erases the old generation count and replaces it.  */
  338.  
  339. updateGeneration() {
  340.     char    genString[255];
  341.     Rect    r;
  342.  
  343.     SetRect(&r, 300,20,450,60);
  344.     FillRect(&r, &qd.white /* CW: qd.white */ );
  345.     
  346.     MoveTo(310,50);
  347.     sprintf(genString, "Generation:  %d", gen);
  348.     DrawString(CtoPstr(genString));
  349. }
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357. /*    Draws the contents of a given cell.  Will draw top item in 
  358.     cells with multiple items, with organisms taking precidence
  359.     over food.   */
  360.  
  361. drawCell (x,y)
  362.     int    x,y;
  363. {
  364.     boolean    isOrg, isFood;
  365.     cell    *currentCell;
  366.     Rect    r;
  367.     int        org_direction, food_type;
  368.     PenState thePen;
  369.  
  370.     
  371.     isOrg = FALSE;
  372.     isFood = FALSE;
  373.     currentCell = world[x][y];
  374.     
  375.     if (gInteractive) {
  376.         /* Find what is in the cell.  */
  377.     
  378.         while (currentCell!=NIL_POINTER) {
  379.             if (currentCell->type==org) {
  380.                 isOrg = TRUE;
  381.                 org_direction = currentCell->datum.ap->direction;
  382.             }
  383.             else if (currentCell->type==food) {
  384.                 isFood = TRUE;
  385.                 food_type = currentCell->datum.atom;
  386.             }
  387. /********** FIL DEBUGGING: above {} and "else" were missing ***********/
  388.             currentCell = currentCell->next;
  389.         }
  390.                 
  391.     
  392.         /* Draw contents of cell in appropriate location  */
  393.     
  394.         SetRect(&r, START_X+x*SQUARE_SIZE, START_Y+y*SQUARE_SIZE, START_X+(x+1)*SQUARE_SIZE - GAP_SIZE, START_Y+(y+1)*SQUARE_SIZE-GAP_SIZE);
  395.         if (isOrg) {
  396.             FillRect(&r, &qd.white /* CW: qd.white */);
  397.             switch (org_direction) {
  398.                 case UP:
  399.                     FillArc(&r, 180+ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  400.                     break;
  401.                 case LEFT:
  402.                     FillArc(&r, 270+ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  403.                     break;
  404.                 case RIGHT:
  405.                     FillArc(&r, 90+ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  406.                     break;
  407.                 case DOWN:
  408.                     FillArc(&r, ORG_MOUTH, 365-2*ORG_MOUTH, &qd.black /* CW: qd.black */ );
  409.                     break;
  410.             }
  411.         }
  412.         else if (isFood)
  413.             switch (food_type) {
  414.                 case 0:
  415.                     FillRect(&r,&qd.ltGray /* CW: qd.ltGray */ );
  416.                     break;
  417.                 case 1:
  418.                     FillRect(&r,&qd.dkGray /* CW: qd.dkGray */ );
  419.                     break;
  420.                 default:
  421.                     FillRect(&r,&qd.gray /* CW: qd.gray */ );
  422.                     break;
  423.             }
  424.         else 
  425.             FillRect(&r, &qd.white /* CW: qd.white */);
  426.     }
  427.     
  428.     if ((x==gCurrentZoomCell.h) && (y==gCurrentZoomCell.v)) 
  429.         UpdateZoomWindow();
  430. }
  431.             
  432.